Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@backend/Src/PIED_LMS.Application/UserCases/Commands/Course/CreateCourseHandler.cs`:
- Around line 83-97: CreateCourseHandler currently calls SaveFileAsync before
validating CurriculumSection and Insight, so if course.SetCurriculum or
course.SetInsight throws (ArgumentException) an uploaded thumbnail is orphaned;
move the validation logic so you construct/validate the domainCurriculum (using
Domain.Entities.CurriculumSection) and validate request.Insight (or call
SetCurriculum/SetInsight on a temp Course object) before invoking SaveFileAsync,
or, if you prefer to keep upload first, catch exceptions after
SetCurriculum/SetInsight and delete the uploaded file by calling the same
storage delete routine used elsewhere; update the try/catch around SetCurriculum
and SetInsight to ensure uploaded file is removed on failure and retain the
logger.LogWarning/ServiceResponse behavior.

In
`@backend/Src/PIED_LMS.Application/UserCases/Commands/Course/UpdateCourseHandler.cs`:
- Around line 131-137: The handler currently calls course.SetCurriculum and
course.SetInsight after performing thumbnail side effects, which can delete the
old thumbnail and upload a new one before validation fails; move all domain
validation (invoke SetCurriculum, SetInsight and any other domain setters that
can throw, e.g., Validate... on the Course aggregate) to run before any
thumbnail Delete/Upload operations so that ArgumentException is raised prior to
making storage changes, and only if validation succeeds proceed to call the
thumbnail methods (e.g., DeleteThumbnail/UploadThumbnail) and then
persist/commit the changes.
- Around line 121-130: The handler currently treats a null
UpdateCourseCommand.Curriculum as an instruction to clear the course curriculum;
change UpdateCourseHandler so that when request.Curriculum is null it does
nothing (preserve existing curriculum), and only call course.SetCurriculum(...)
when request.Curriculum is non-null — mapping items to
Domain.Entities.CurriculumSection for a non-empty list, and explicitly clearing
(e.g. course.SetCurriculum(null) or an agreed “clear” value) only when
request.Curriculum is an empty list; update the branch around request.Curriculum
and calls to course.SetCurriculum accordingly.

In `@backend/Src/PIED_LMS.Domain/Entities/CurriculumSection.cs`:
- Around line 7-25: The Content property currently exposes a mutable
List<string> and the constructor stores the caller's list reference directly;
change CurriculumSection.Content to expose an immutable/read-only type (e.g.,
IReadOnlyList<string> or ReadOnlyCollection<string>) and in the
CurriculumSection(string title, string summary, List<string> content)
constructor make a defensive copy of the incoming list (new
List<string>(content)) and assign a read-only wrapper (e.g., AsReadOnly or cast
to IReadOnlyList) so consumers cannot mutate the internal collection after
construction while preserving EF compatibility via the private parameterless
constructor.

In `@backend/Src/PIED_LMS.Persistence/Configurations/CourseConfiguration.cs`:
- Line 1: Course.Curriculum is mapped via JSON conversion but lacks a
ValueComparer, so EF Core will track snapshots by reference and miss in-place
edits; in CourseConfiguration add a ValueComparer for the converted type (e.g.,
ValueComparer<List<CurriculumSection>>) and attach it to the property metadata
(via .Metadata.SetValueComparer(...) or the fluent API). Implement the comparer
to compare value equality (either by comparing serialized JSON strings or deep
sequence equality on CurriculumSection items) and to produce snapshots by
cloning (e.g., via JsonSerializer serialize/deserialize) so mutations of
CurriculumSection.Content are detected; update the CourseConfiguration mapping
for the Curriculum property to use this comparer alongside the existing
HasConversion/JsonSerializer usage.

---

Outside diff comments:
In `@backend/Src/PIED_LMS.Domain/Entities/Course.cs`:
- Around line 24-40: Course.Curriculum is exposed as a mutable List allowing
external mutation and bypassing domain validation; change it to expose a
read-only collection (IReadOnlyList<CurriculumSection> or
ReadOnlyCollection<CurriculumSection>) backed by a private
List<CurriculumSection> field (e.g., _curriculum), and update SetCurriculum to
assign a defensive copy (new List<CurriculumSection>(curriculum ??
Enumerable.Empty<CurriculumSection>())) to that private field; have the public
Curriculum getter return the read-only view (e.g., _curriculum.AsReadOnly() or
the IReadOnlyList) so callers cannot mutate the aggregate or the original list
after SetCurriculum returns.